package com.lwd1513.designPattern.factory.responsibilitychain;

/**
 * 刘东
 */
public abstract class AbstractRobotHandler implements RobotHandler {

    /**
     * 下一处理器
     */
    protected RobotHandler next;

    /**
     * @param request
     * @param robot
     * @return
     */
    @Override
    public Object handle(RobotRequest request, Robot robot) {
        /**
         * 是否跳过当前处理节点
         */
        if (skipCurrentHandler(request, robot)) {
            return next.handle(request, robot);
        }
        Object response = doHandler(request, robot);
        /**
         * 执行链的临界点 返回值不为null 如果已经获取到结果 直接返回最终结果
         */
        if (response != null) {
            return response;
        }
        /**
         * 当前节点处理完 如果还有下一个接待你 继续处理
         */
        if (next != null) {
            return next.handle(request, robot);
        }
        return null;
    }

    /**
     * 具体执行方法
     *
     * @param request
     * @param robot
     * @return
     */
    protected abstract Object doHandler(RobotRequest request, Robot robot);

    /**
     * 设置 下一处理器
     *
     * @param robotHandler
     */
    @Override
    public void setNextRobotHandler(RobotHandler robotHandler) {
        next = robotHandler;
    }

    /**
     * 最终的响应类是 KnClientResponse
     * 链路中可能会产生很多工厂bean类 和bean类 链路上传递的是Object
     * 针对链路处理中获取返回的值进行处理
     * 返回过程中再次处理获取的结果
     * 开始 -->1-->2-->3--->4
     * 结束    <--1---2<--4
     * 获取KnClientResponse
     * 1.response是KnClientResponse或者ResponseFactory类型返回nClientResponse
     * 2.否者返回null
     *
     * @param response
     * @return
     */
    protected KnClientResponse getKnClientResponse(Object response) {
        if (response == null) {
            return null;
        }
        if (response instanceof KnClientResponse) {
            return (KnClientResponse) response;
        } else if (response instanceof ResponseFactory) {
            return ((ResponseFactory) response).getKnClientResponse();
        }
        return null;
    }

    /**
     * 跳过当前处理器
     *
     * @param request
     * @param robot
     * @return
     */
    protected boolean skipCurrentHandler(RobotRequest request, Robot robot) {
        return !support(request, robot);
    }

    /**
     * 默认都不跳过
     * @param request
     * @param robot
     * @return
     */
    protected boolean support(RobotRequest request, Robot robot) {
        return true;
    }
}